home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / StaticTView.C < prev    next >
C/C++ Source or Header  |  1990-12-06  |  17KB  |  719 lines
  1. //$StaticTextView,LineMark$
  2. overload Swap;
  3.  
  4. #include "StaticTView.h"
  5. #include "String.h"
  6. #include "View.h"
  7. #include "BlankWin.h"
  8. #include "FixedStorage.h"
  9. #include "TextFormatter.h"
  10.  
  11. Rectangle gFitRect(cFit, cFit);
  12.  
  13. //---- class LineMark ------------------------------------------------------
  14.  
  15. MetaImpl0(LineMark);
  16.  
  17. int LineMark_lineChanged;
  18.  
  19. LineMark::LineMark(LineDesc ldesc, int pos, int len, eMarkState s)
  20.                                 : Mark(pos, len, s)
  21. {
  22.     ld = ldesc; 
  23. }
  24.  
  25. LineMark::~LineMark()
  26. {
  27. }
  28.  
  29. ostream& LineMark::DisplayOn (ostream&s)
  30. { 
  31.     Mark::DisplayOn(s);
  32.     return s << ld.lnAscent << "/" << ld.lnHeight; 
  33. }
  34.  
  35. void *LineMark::operator new(size_t sz)
  36. {
  37.     return MemPools::Alloc(sz);
  38. }
  39.  
  40. void LineMark::operator delete(void *vp)
  41. {
  42.     MemPools::Free(vp, sizeof(LineMark)); 
  43. }
  44.  
  45. //---- global functions --------------------------------------------------
  46.  
  47. int TextViewLineHeight(FontPtr fd, eSpacing sp)
  48. { 
  49.     return ((int) sp) * fd->Spacing() / 2;
  50. }
  51.  
  52. //----- StaticTextView Methods --------------------------------------------------
  53.  
  54. MetaImpl(StaticTextView, (TP(text), TE(just), TE(spacing), TB(wrap),
  55.     TB(drawViewBorder), TB(vertExtend), TB(horExtend), T(border),
  56.     T(nLines), TP(lines), TP(marks), 0));
  57.  
  58. StaticTextView::StaticTextView(EvtHandler *eh, Rectangle r, Text *t, eTextJust m, 
  59.       eSpacing sp, bool doWrap, TextViewFlags fl, Point b, int id) 
  60.                                 : View(eh,r,id) 
  61. {
  62.     Init(r, t, m, sp, doWrap, fl, b);
  63. }   
  64.  
  65. void StaticTextView::Init(Rectangle r, Text* t, eTextJust ej, eSpacing sp, 
  66.             bool doWrap, TextViewFlags flags, Point itsBorder)
  67. {
  68.     lines= new ObjArray(32);
  69.     contentRect= r;
  70.     text= t;
  71.     nextc= text->MakeIterator();
  72.     just= ej;
  73.     spacing= sp;
  74.     wrap= doWrap;
  75.     drawViewBorder= FALSE;
  76.     marks= new MarkList;
  77.     LineDesc ld;
  78.     lines->AtPut(0,new LineMark(ld)); //dummy
  79.     marks->Add((*lines)[0]);    
  80.     vertExtend= (contentRect.extent.y == cFit);
  81.     horExtend= (contentRect.extent.x == cFit);
  82.     border= itsBorder;
  83.     if (horExtend)
  84.     wrap= FALSE;
  85.     if (!wrap)
  86.     formatter= new SimpleFormatter(this);
  87.     else
  88.     formatter= new FoldingFormatter(this);
  89.     nLines= 0;
  90.     fixedSpacing.FromFont(text->GetFont());
  91.     formatter->Preemptive(FALSE);
  92.     ChangedAt(0);
  93.     formatter->Preemptive(TRUE);
  94.  
  95.     if ((flags & eTextViewVisMode) == eTextViewVisMode)
  96.     SetFlag(eTextViewVisMode);
  97.     if ((flags & eTextViewReadOnly) == eTextViewReadOnly)
  98.     SetFlag(eTextViewReadOnly);
  99.     if ((flags & eTextFormPreempt) == eTextFormPreempt)
  100.     SetFlag(eTextFormPreempt);
  101.     if ((flags & eTextFixedOrigin) == eTextFixedOrigin)
  102.     SetFlag(eTextFixedOrigin);
  103.     if ((flags & eTextViewNoBatch) == eTextViewNoBatch)
  104.     SetFlag(eTextViewNoBatch);
  105.     if ((flags & eTextFixedSpacing) == eTextFixedSpacing)
  106.     SetFlag(eTextFixedSpacing);
  107. }
  108.  
  109. bool StaticTextView::IsJustified(int endOfLine)
  110. {
  111.     return (just == eJustified && endOfLine != text->Size() &&
  112.         (*text)[endOfLine-1] != '\n' && (*text)[endOfLine-1] != '\r');
  113. }
  114.  
  115. StaticTextView::~StaticTextView()
  116. {
  117.     if (lines)
  118.     lines->FreeAll();
  119.     SafeDelete(formatter);
  120.     SafeDelete(marks);
  121.     SafeDelete(lines);
  122.     SafeDelete(nextc);
  123. }
  124.  
  125. void StaticTextView::Draw(Rectangle r)
  126. {
  127.     register int i, lh, bh;
  128.     int startAt= PointToLine(r.origin-GetInnerOrigin()); // r is in View coords
  129.     Ink *oldtextink= 0; 
  130.  
  131.     if (startAt >= nLines)
  132.     return;
  133.        
  134.     Point p= LineToPoint(startAt,TRUE) + GetInnerOrigin();
  135.     Rectangle lineRect(GetInnerOrigin().x, p.y-BaseHeight(startAt),
  136.                    GetInnerExtent().x, LineHeight(startAt));
  137.  
  138.     if (! Enabled()) {
  139.     oldtextink= port->textink; // hack
  140.     GrSetTextPattern(ePatGrey50);
  141.     }
  142.  
  143.     bh= BaseHeight(startAt);
  144.     for (i= startAt; ; i++) {
  145.     if (! r.Intersects(lineRect))
  146.         break;
  147.     DrawLine(p, i, lineRect, r);
  148.     if (i >= nLines-1)
  149.         break;
  150.     p.y+= (lh= LineHeight(i))-bh;
  151.     p.y+= (bh= BaseHeight(i+1));
  152.     lineRect.origin.y+= lh; 
  153.     }        
  154.     if (drawViewBorder) {
  155.     GrSetPenPattern(ePatGrey50);
  156.     GrSetPenSize(2);
  157.     GrStrokeRect (Rectangle (contentRect.origin,contentRect.extent));
  158.     }
  159.     if (! Enabled())
  160.     GrSetTextPattern(oldtextink);
  161. }
  162.  
  163. void StaticTextView::DrawLine (Point p,int i,Rectangle, Rectangle rr)
  164. {
  165.     int start= StartLine(i), end= EndLine(i);
  166.     bool justified= IsJustified(end);
  167.     
  168.     p.x+= FirstCharPos(start, end);
  169.     if (Isspace((*text)[end-1]) && !TestFlag(eTextViewVisMode))     
  170.     end= max(start, --end);
  171.     GrTextMoveto(p);
  172.     if (justified)
  173.     text->DrawTextJust(start, end, GetInnerExtent().x, p, rr);
  174.     else
  175.     text->DrawText(start, end, rr);
  176. }
  177.  
  178. void StaticTextView::SetFont(FontPtr fd)
  179. {
  180.     text->SetFont(fd);
  181.     Reformat();
  182. }
  183.  
  184. void StaticTextView::SetSpacing(eSpacing sp)
  185. {
  186.     spacing = sp;
  187.     Reformat();
  188. }
  189.  
  190. void StaticTextView::SetFormatter(TextFormatter *f)
  191. {
  192.     SafeDelete(formatter);
  193.     formatter= f;
  194. }
  195.  
  196. void StaticTextView::SetJust(eTextJust m)
  197. {
  198.     just = m;
  199.     Reformat();
  200. }
  201.  
  202. void StaticTextView::SetVisibleMode(bool m)
  203. {
  204.     SetFlag(eTextViewVisMode, m);
  205.     Reformat();
  206. }
  207.  
  208. bool StaticTextView::GetVisibleMode()
  209. { 
  210.     return TestFlag(eTextViewVisMode); 
  211. }
  212.  
  213. void StaticTextView::SetWordWrap(bool m)
  214. { 
  215.     if (wrap == m)
  216.     return;
  217.     wrap= m;
  218.     SafeDelete(formatter);
  219.     if (wrap)
  220.     formatter= new FoldingFormatter(this); 
  221.     else
  222.     formatter= new SimpleFormatter(this); 
  223.     Reformat();
  224. }
  225.  
  226. bool StaticTextView::GetWordWrap()
  227. { 
  228.     return wrap; 
  229. }
  230.  
  231. void StaticTextView::SetNoBatch(bool m)
  232. {
  233.     SetFlag(eTextViewNoBatch, m);
  234. }
  235.  
  236. bool StaticTextView::GetNoBatch()
  237. { 
  238.     return TestFlag(eTextViewNoBatch); 
  239. }
  240.  
  241. Text *StaticTextView::SetText(Text *t)
  242. {
  243.     Text *old= text;
  244.     text= t;   
  245.     nextc= text->MakeIterator();
  246.     Reformat();  
  247.     Send(GetId(), cPartReplacedText, 0);
  248.     return old;
  249. }
  250.  
  251. void StaticTextView::SetString(byte *str, int len)
  252. {
  253.     text->ReplaceWithStr(str, len);
  254.     Reformat();
  255.     Send(GetId(), cPartReplacedText, 0);  
  256. }
  257.  
  258. int StaticTextView::NumberOfLines()
  259. {
  260.     return nLines;
  261. }
  262.  
  263. void StaticTextView::StartFormatting()
  264. {
  265. }
  266.  
  267. void StaticTextView::Reformat()
  268. {
  269.     nLines= 0;
  270.     formatter->Preemptive(FALSE);
  271.     ChangedAt(0);
  272.     formatter->Preemptive(TRUE);
  273. }
  274.  
  275. //---- mark a line and return whether line changed
  276.  
  277. bool StaticTextView::MarkLine (int line,int start,int end,LineDesc *ld)
  278. {
  279.     LineMark *m = 0;
  280.     bool markChanged;
  281.  
  282.     if (TestFlag(eTextFixedSpacing)) {
  283.     LineDesc tmp= fixedSpacing;
  284.     fixedSpacing.Max(*ld);
  285.     if (!tmp.IsEqual(fixedSpacing))
  286.         ForceRedraw();
  287.     *ld= fixedSpacing;    
  288.     }
  289.  
  290.     if (line < lines->Size())   
  291.     m = MarkAtLine(line);
  292.  
  293.     if (m) {
  294.     markChanged = m->HasChanged(start,end-start) || line >= nLines;
  295.     m->ChangeMark(start,end-start,*ld);
  296.     ld->Reset();
  297.     return markChanged;
  298.     }    
  299.     m = new LineMark(*ld,start,end - start);
  300.     ld->Reset();
  301.     marks->Add(m);
  302.     lines->AtPutAndExpand(line,m);
  303.     return TRUE;
  304. }
  305.  
  306. void StaticTextView::MarkLineAsChanged (int line)
  307. {
  308.     LineMark *m = MarkAtLine(max(0,min(line,nLines-1)));
  309.     m->state = eStateChanged;   
  310. }
  311.  
  312. bool StaticTextView::SuspendFormatting()
  313. {
  314.     Token t= gWindow->ReadEvent(0);
  315.     if (t.Code != eEvtNone) {
  316.     gWindow->PushBackEvent(t);
  317.     return TRUE;
  318.     }
  319.     return FALSE;  
  320. }
  321.  
  322. void StaticTextView::SetExtent(Point p)
  323. {
  324.     if (p != contentRect.extent) {
  325.     View::SetExtent(p);
  326.     if (horExtend)
  327.         wrap= FALSE;
  328.     Reformat();
  329.     }
  330. }
  331.  
  332. Metric StaticTextView::GetMinSize()
  333. {
  334.     Reformat();
  335.     return Metric(GetExtent(), Base());
  336. }
  337.  
  338. int StaticTextView::Base()
  339. {
  340.     return LineToPoint(0, TRUE).y+border.y;
  341. }
  342.  
  343. void StaticTextView::Fit()
  344. {
  345.     Point newExtent(contentRect.extent);
  346.     Point newOrigin(contentRect.origin);
  347.     register int i, s, e;
  348.  
  349.     if (vertExtend) 
  350.     newExtent.y = LineToPoint(nLines).y + 2*border.y;
  351.  
  352.     if (horExtend) {
  353.     newExtent.x = 0;
  354.     for (i= 0; i < nLines; i++) {
  355.         s= StartLine(i);
  356.         e= EndLine(i);
  357.         newExtent.x = max(newExtent.x, text->TextWidth(s,e));
  358.         if (!TestFlag(eTextFixedOrigin)) {
  359.         // adjust origin
  360.         switch (just) {
  361.         case eCenter:
  362.             newOrigin.x = contentRect.origin.x + 
  363.                   (contentRect.extent.x-newExtent.x)/2;
  364.             break;
  365.         case eRight:
  366.             newOrigin.x = contentRect.origin.x + 
  367.                   (contentRect.extent.x-newExtent.x);
  368.             break;
  369.         }
  370.         }
  371.     }
  372.     newExtent.x += 2*border.x;
  373.     }
  374.  
  375.     // the height of the view is at least the height of one line
  376.     newExtent.y = max(newExtent.y,
  377.               TextViewLineHeight(text->GetFont(), spacing)+2*border.y);
  378.  
  379.     // invalidate difference Rects if necessary
  380.     if (newExtent.x < contentRect.extent.x || newExtent.y < contentRect.extent.y) {
  381.     Rectangle r[4], tmpRect;
  382.     // expanded by 4,0 to invalidate the caret
  383.     tmpRect= contentRect.Expand(Point(4,0)); // g++??
  384.     int n= Difference(r, tmpRect, Rectangle(newOrigin,newExtent));
  385.     for (int i= 0; i < n; i++) 
  386.         InvalidateRect(r[i]);
  387.     }   
  388.     if (newOrigin != contentRect.origin) {
  389.     View::SetOrigin(newOrigin);
  390.     if (TestFlag(eVObjLayoutCntl)) 
  391.         Control(GetId(), cPartOriginChanged, this);
  392.     Send(GetId(), cPartOriginChanged, this); 
  393.     }
  394.     if (newExtent != contentRect.extent) {
  395.     View::SetExtent(newExtent);
  396.     if (TestFlag(eTextFixedOrigin)) 
  397.        InvalidateRect(contentRect);
  398.     if (TestFlag(eVObjLayoutCntl)) 
  399.         Control(GetId(), cPartExtentChanged, this);
  400.     Send(GetId(), cPartExtentChanged, this); 
  401.     }    
  402. }
  403.  
  404. Point StaticTextView::LineToPoint (int n, bool basePoint, bool relative)
  405. {
  406.     register int i, y= 0;
  407.  
  408.     n= range(0, nLines, n);
  409.     for (i= 0; i < n; i++)
  410.     y+= LineHeight(i);
  411.  
  412.     if (basePoint)
  413.     y+= BaseHeight(n);
  414.     if (relative)
  415.     return Point(0, y);
  416.     return GetInnerOrigin() + Point(0, y);
  417. }
  418.  
  419. int StaticTextView::PointToLine(Point p) // p is in coordinates relative to contentRect
  420. {
  421.     register int line, y= 0, py= max(0, p.y), lh;
  422.     
  423.     for (line= 0; line < nLines; line++) {
  424.     if (y + (lh= LineHeight(line)) > py)
  425.         break;
  426.     y+= lh;
  427.     }
  428.     return (min(nLines, line));
  429. }
  430.  
  431. //---- map a point in view coordinates to line and character number
  432.  
  433. void StaticTextView::PointToPos(Point p, Point *viewPos, int *lineNo, int *charNo)
  434. {
  435.     int start, end, fx= 0, cx= 0, l= *lineNo; // ???
  436.  
  437.     l = PointToLine(p);
  438.     if (l >= nLines) {
  439.     l = nLines-1;
  440.     p.x = contentRect.extent.x;    // set to end of line
  441.     }
  442.     if (l < 0) {
  443.     l = 0;
  444.     p.x = 0;            // set to start of line
  445.     }
  446.     start  = StartLine(l);
  447.     end    = EndLine(l);
  448.  
  449.     fx = FirstCharPos (start,end);
  450.  
  451.     bool justified = IsJustified(end);
  452.  
  453.     // make new lines at end of line not selectable
  454.     if (end - start) {
  455.     if ((*text)[end-1] == '\n' || (*text)[end-1] == '\r')
  456.         end--;
  457.     if (wrap && (*text)[end-1] == ' ')
  458.         end--;
  459.     }
  460.     if (justified) 
  461.     text->JustifiedMap(start, end, GetInnerExtent().x, end, p.x-fx, charNo, &cx); 
  462.     else
  463.     text->Map(start, end, end, p.x-fx, charNo, &cx);
  464.     *lineNo = l;
  465.     *viewPos = Point(cx+fx,LineToPoint(l).y);
  466. }
  467.  
  468. int StaticTextView::CharToLine(int ch)
  469. {
  470.     //register int line;
  471.     //for (line= 0; line < nLines; line++)
  472.     //    if (EndLine(line) > ch) 
  473.     //        break;
  474.     //return max(0, min(line, nLines-1));
  475.     register int base, pos, last, s;
  476.     
  477.     base= pos= 0;
  478.     last= nLines-1;
  479.     
  480.     while (last >= base) { // binary search
  481.     pos= (base+last) / 2;
  482.     if (EndLine(pos) > ch && (s= StartLine(pos)) <= ch)
  483.         break;
  484.     if (StartLine(pos) > ch)
  485.         last= pos-1;
  486.     else
  487.         base= pos+1;
  488.     }
  489.     return max(0, min(pos, nLines-1));
  490. }
  491.  
  492. void StaticTextView::CharToPos (int charNo, int *lineNo, Point *viewPos, bool relative)
  493. {
  494.     int line, ch, start, end, x;
  495.     Point p;
  496.  
  497.     ch= min(max(0,charNo),text->Size()); // establish 0 <= ch <= size
  498.     line= CharToLine(ch);
  499.     p.y= LineToPoint(line).y;
  500.     if (line >= nLines && line > 0) { // beyound end of text
  501.     p.y-= LineHeight(line);
  502.     line= max(0,nLines-1);
  503.     }
  504.     start= StartLine(line);
  505.     end= EndLine(line);
  506.  
  507.     //-- find character position    
  508.     p.x= FirstCharPos (start,end);
  509.  
  510.     bool justified= IsJustified(end);
  511.     if (justified) 
  512.     text->JustifiedMap(start, end, GetInnerExtent().x, charNo, cMaxInt, 0, &x);
  513.     else
  514.     text->Map(start, end, charNo, cMaxInt, 0, &x);
  515.     *viewPos= p;
  516.     viewPos->x+= x;
  517.     if (!relative)
  518.     *viewPos += GetInnerOrigin();
  519.     *lineNo= line;
  520. }
  521.  
  522. #include "System.h"
  523.  
  524. static int hcacheline= -1 , hcachelh= 0;
  525.  
  526. int StaticTextView::LineHeight(int l)
  527. {
  528.     if (hcacheline != l) {
  529.     // hcacheline= l;
  530.     
  531.     hcachelh= TestFlag(eTextFixedSpacing) ? 
  532.         TextViewlh(spacing, fixedSpacing.lnHeight) :
  533.         l >= nLines ? 
  534.         OutOfRangeLineMetric(TRUE) :
  535.         TextViewlh(spacing, MarkAtLine(l)->ld.lnHeight);
  536.     }
  537.     return hcachelh;
  538. }
  539.     
  540. static int bcacheline= -1 , bcachelb= 0;
  541.  
  542. int StaticTextView::BaseHeight(int l)
  543. {
  544.     if (bcacheline != l) {
  545.     // bcacheline= l;
  546.     
  547.     bcachelb= TestFlag(eTextFixedSpacing) ? 
  548.         fixedSpacing.lnAscent :
  549.         l >=nLines ? 
  550.         OutOfRangeLineMetric(FALSE) : 
  551.         MarkAtLine(l)->ld.lnAscent;
  552.     }
  553.     return bcachelb;
  554. }
  555.  
  556. int StaticTextView::FirstCharPos (int from,int to)
  557. {
  558.     //---- strip trailing whitespace, blank, tab or new line
  559.     if (Isspace((*text)[to-1]))
  560.     to= max(0, --to);
  561.  
  562.     switch (just) {
  563.     case eCenter:
  564.     return (GetInnerExtent().x - text->TextWidth(from,to))/2;
  565.     case eRight:
  566.     return GetInnerExtent().x - text->TextWidth(from,to);
  567.     }
  568.     return 0;
  569. }
  570.  
  571. void StaticTextView::ChangedAt(int line, int, bool redrawAll, int minUpto)
  572. { 
  573.     int start, to;
  574.  
  575.     LineMark_lineChanged= FALSE;
  576.     
  577.     to= formatter->DoIt(line, cMaxInt, minUpto);
  578.     start= formatter->StartedAt();
  579.     nLines= max(nLines, to+1);
  580.     
  581.     if (vertExtend || horExtend)
  582.     Fit(); 
  583.     if (redrawAll || LineMark_lineChanged)
  584.     to= nLines-1;
  585.     InvalidateRange(start, max(to, start));
  586. }
  587.  
  588. void StaticTextView::InvalidateRange(int from, int to)
  589. {
  590.     if (from > to)  // normalize range
  591.     swap(from, to);
  592.     Point p= LineToPoint(from),
  593.       t= Point(contentRect.extent.x, LineToPoint(to).y+LineHeight(to));
  594.     Rectangle r= NormRect(p, t);
  595.  
  596.     r += GetInnerOrigin();
  597.     if (from == 0)  { // consider border
  598.     r.origin.y -= border.y;
  599.     r.extent.y += border.y;
  600.     }
  601.     if (to == nLines-1 || to == 0) 
  602.     r.extent.y += border.y;
  603.     InvalidateRect(r.Expand(Point(max(4,border.x),0)));
  604. }
  605.  
  606. void StaticTextView::InvalidateRange(int from, Point fp, int to, Point tp)
  607. {
  608.     Rectangle r, r1;
  609.  
  610.     from= range(0, nLines, from);
  611.     to=   range(0, nLines, to);
  612.  
  613.     if ((from == to && fp.x > tp.x) || from > to) { // normalize range
  614.     swap(from, to);
  615.     Swap(fp, tp);   
  616.     }
  617.  
  618.     if (from == to) { // optimize invalidate on one line
  619.     r= Rectangle(LineToPoint(from)+Point (fp.x,0),
  620.                     Point(tp.x-fp.x, LineHeight(from)));
  621.     if (from == 0)  { // consider border
  622.         r.origin.y -= border.y;
  623.         r.extent.y += border.y;
  624.     }
  625.     if (to == nLines-1 || to == 0) 
  626.         r.extent.y += border.y;
  627.     r.origin+= GetInnerOrigin();
  628.     InvalidateRect(r.Expand(Point(max(4,border.x),0)));
  629.     return;
  630.     }
  631.     InvalidateRange(from, to);
  632. }
  633.  
  634. void StaticTextView::Dump()
  635. {
  636.     drawViewBorder = TRUE;    
  637.     cerr << "Lines: " << nLines NL;
  638.     cerr << "Contents:\n"<< *text NL;
  639.     for (int i = 0; i < nLines; i++)
  640.     cerr << i << "." << (*lines)[i]->ClassName(), (*lines)[i]->DisplayOn(cerr), cerr NL;;
  641. }
  642.  
  643. char *StaticTextView::AsString()
  644. {
  645.     return text->AsString();
  646. }
  647.  
  648. ostream& StaticTextView::PrintOn (ostream&s)
  649. {
  650.     View::PrintOn(s);
  651.     return s << text SP << wrap SP << spacing SP << just SP << 
  652.         vertExtend SP << horExtend SP << border SP << contentRect.extent;
  653. }
  654.  
  655. istream& StaticTextView::ReadFrom(istream &s)
  656. {
  657.     Text *txt;
  658.     bool wrap, vExtend, hExtend;
  659.     Point extent, itsBorder;
  660.     eSpacing sp;
  661.     eTextJust just;
  662.     Rectangle r;
  663.  
  664.     SafeDelete(text);
  665.  
  666.     View::ReadFrom(s);
  667.     s >> txt >> Bool(wrap) >> Enum(sp) >> Enum(just) >> Bool(vExtend)
  668.                     >> Bool(hExtend) >> itsBorder >> extent;
  669.     r= Rectangle(extent);
  670.     if (vExtend)
  671.     r.extent.y = cFit;
  672.     if (hExtend)
  673.     r.extent.x = cFit;
  674.  
  675.     Init(r, txt, just, sp, wrap, eTextViewNone, itsBorder);
  676.     return s;
  677. }
  678.  
  679. void StaticTextView::AddMark(Mark *m)
  680. {
  681.     text->AddMark(m);
  682. }
  683.  
  684. Mark *StaticTextView::RemoveMark(Mark *m)
  685. {
  686.     return text->RemoveMark(m);
  687. }
  688.  
  689. Iterator *StaticTextView::GetMarkIter()
  690. {
  691.     return text->GetMarkIter();
  692. }
  693.  
  694. MarkList *StaticTextView::GetMarkList()
  695. {
  696.     return text->GetMarkList();
  697. }
  698.  
  699. int StaticTextView::OutOfRangeLineMetric(bool lineHeight)
  700. {
  701.     if (lineHeight)
  702.     return TextViewLineHeight(text->GetFont(), spacing);  
  703.     return text->GetFont()->Ascender();      
  704. }
  705.  
  706. void StaticTextView::InspectorId(char *buf, int sz)
  707. {
  708.     if (text)
  709.     text->InspectorId(buf, sz);
  710.     else
  711.     View::InspectorId(buf, sz);
  712. }
  713.  
  714. void StaticTextView::Parts(Collection* col)
  715. {
  716.     View::Parts(col);
  717.     col->Add(text);
  718. }        
  719.